home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / stdlib1.exe / lha / LTOA.ASM < prev    next >
Assembly Source File  |  1990-07-08  |  3KB  |  145 lines
  1. ;
  2. stdlib        segment    para public 'slcode'
  3.         assume    cs:stdlib
  4.         extrn    sl_malloc:far
  5. ;
  6. ; Local variables for these routines:
  7. ;
  8. astr        db    12 dup (?)
  9. aindex        dw    0
  10. ;
  11. ;
  12. ; LTOA-    converts the value in DX:AX to a string.  Returns a pointer to this
  13. ;    string in ES:SI.  Carry=0 on return if no error, 1 if heap overflow.
  14. ;
  15.         public    sl_ltoa
  16. sl_ltoa        proc    far
  17.         push    ax
  18.         push    bx
  19.         push    cx
  20.         push    dx
  21.         mov    cs:aindex, 0
  22.         cmp    dx, 0
  23.         jge    Doit
  24.         push    ax
  25.         mov    al, '-'
  26.         call    Putit
  27.         pop    ax
  28.         neg    dx
  29.         neg    ax
  30.         sbb    dx, 0
  31. ;
  32. DoIt:        call    puti2
  33. ;
  34. ; Move the digit string out onto the heap and return a pointer to it in
  35. ; es:si.
  36. ;
  37.         mov    cx, cs:aindex
  38.         mov    bx, cx            ;Save for later.
  39.         inc    cx
  40.         call    sl_malloc               ;Allocate storage for string.
  41.         jc    BadLTOA
  42. CopyStrLp:    mov    al, cs:astr[bx]
  43.         mov    es:[di][bx], al
  44.         dec    bx
  45.         jns    CopyStrLp
  46.         clc
  47.         pop    dx
  48.         pop    cx
  49.         pop    bx
  50.         pop    ax
  51.         ret
  52. ;
  53. BadLTOA:    clc
  54.         pop    dx cx bx ax
  55.         ret
  56. sl_ltoa        endp
  57. ;
  58. ;
  59. ;
  60. ; ULTOA converts the unsigned dword value in DX:AX to a string and returns
  61. ;    a pointer to this string in ES:SI.  Carry=0 if no error, 1 if heap
  62. ;    overflow occurs.
  63. ;
  64.         public    sl_ultoa
  65. sl_ultoa    proc    far
  66.         push    ax
  67.         push    bx
  68.         push    cx
  69.         push    dx
  70.         mov    cs:aindex, 0
  71.         call    PutI2
  72. ;
  73. ; Move the digit string out onto the heap and return a pointer to it in
  74. ; es:si.
  75. ;
  76.         mov    cx, cs:aindex
  77.         mov    bx, cx            ;Save for later.
  78.         inc    cx
  79.         call    sl_malloc               ;Allocate storage for string.
  80.         jc    BadULTOA
  81. CopyStrLp2:    mov    al, cs:astr[bx]
  82.         mov    es:[di][bx], al
  83.         dec    bx
  84.         jns    CopyStrLp2
  85.         clc
  86.         pop    dx
  87.         pop    cx
  88.         pop    bx
  89.         pop    ax
  90.         ret
  91. ;
  92. BadULTOA:    stc
  93.         pop    dx cx bx ax
  94.         ret
  95. sl_ultoa    endp
  96. ;
  97. ;
  98. ;
  99. ; PutI2- Recursive routine to actually print the value in AX as an integer.
  100. ;
  101. Puti2        proc    near
  102.         call    Div10
  103.         cmp    ax, dx        ;See if dx:ax=0
  104.         jnz    NotDone
  105.         or    ax, ax
  106.         jz    Done
  107. NotDone:    push    bx
  108.         call    Puti2
  109.         pop    bx
  110. Done:        mov    al, bl
  111.         or    al, '0'
  112.         call    PutIt
  113.         ret
  114. PutI2        endp
  115. ;
  116. ; Div10- Divides DX:AX by 10 leaving the remainder in BL and the quotient
  117. ;     in DX:AX.
  118. ;
  119. Div10        proc    near
  120.         mov    cx, 10
  121.         mov    bx, ax
  122.         xchg    ax, dx
  123.         xor    dx, dx
  124.         div    cx
  125.         xchg    bx, ax
  126.         div    cx
  127.         xchg    dx, bx
  128.         ret
  129. Div10        endp
  130. ;
  131. ;
  132. ; PutIt- Writes the character in AL to the "astr" buffer.  Also zero
  133. ; terminates the string and increments aindex.  Note: no need to preserve
  134. ; SI here because no one else uses it.
  135. ;
  136. PutIt        proc    near
  137.         mov    di, cs:aindex
  138.         mov    cs:astr[di], al
  139.         mov    byte ptr cs:astr+1[di], 0
  140.         inc     cs:aindex
  141.         ret
  142. PutIt        endp
  143. stdlib        ends
  144.         end
  145.